home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 001 / pibt40s1.arc / DISPLAYC.MOD < prev    next >
Text File  |  1987-05-25  |  12KB  |  308 lines
  1. (*----------------------------------------------------------------------*)
  2. (*           Display_Character --- show character received from port    *)
  3. (*----------------------------------------------------------------------*)
  4.  
  5. PROCEDURE Display_Character( Ch: CHAR );
  6.  
  7. (*----------------------------------------------------------------------*)
  8. (*                                                                      *)
  9. (*     Procedure:  Display_Character                                    *)
  10. (*                                                                      *)
  11. (*     Purpose:    Displays character received from comm. port on       *)
  12. (*                 screen/printer/capture file.                         *)
  13. (*                                                                      *)
  14. (*     Calling Sequence:                                                *)
  15. (*                                                                      *)
  16. (*        Display_Character( Ch : CHAR );                               *)
  17. (*                                                                      *)
  18. (*           Ch         --- Character received from Comm. port.         *)
  19. (*                                                                      *)
  20. (*      Calls:   Async_Receive                                          *)
  21. (*               Min                                                    *)
  22. (*               Update_Review_Pointers                                 *)
  23. (*               TimeOfDay                                              *)
  24. (*               TimeDiff                                               *)
  25. (*                                                                      *)
  26. (*      Remarks:                                                        *)
  27. (*                                                                      *)
  28. (*         This routine strips out certain characters which             *)
  29. (*         should not be displayed, performs output line wrapping,      *)
  30. (*         and saves the output line characters in the review buffer.   *)
  31. (*                                                                      *)
  32. (*----------------------------------------------------------------------*)
  33.  
  34. (* STRUCTURED *) CONST
  35.    CR_Ch    : CHAR = ^M;
  36.    LF_Ch    : CHAR = ^J;
  37.    BL_Ch    : CHAR = ' ';
  38.                                    (* Terminal types so effect of FF *)
  39.                                    (* can be distinguished           *)
  40.    Ansi_Set : SET OF Terminal_Type
  41.               = [Ansi, VT52, VT100];
  42.  
  43. VAR
  44.    I    : INTEGER;
  45.    J    : INTEGER;
  46.    L    : INTEGER;
  47.    Xpos : INTEGER;
  48.    Ypos : INTEGER;
  49.    KeyC : CHAR;
  50.    Disp : BOOLEAN;
  51.  
  52. (*----------------------------------------------------------------------*)
  53. (*       MoveXY --- Move to (X,Y) on screen using BIOS call             *)
  54. (*----------------------------------------------------------------------*)
  55.  
  56. PROCEDURE MoveXY( X: INTEGER; Y: INTEGER );
  57.  
  58. (*----------------------------------------------------------------------*)
  59. (*                                                                      *)
  60. (*     Procedure:  MoveXY                                               *)
  61. (*                                                                      *)
  62. (*     Purpose:    Moves to specified (X,Y) position on screen          *)
  63. (*                                                                      *)
  64. (*     Calling Sequence:                                                *)
  65. (*                                                                      *)
  66. (*        MoveXY( X: INTEGER; Y: INTEGER );                             *)
  67. (*                                                                      *)
  68. (*           (X,Y)  --- Where to move to                                *)
  69. (*                                                                      *)
  70. (*----------------------------------------------------------------------*)
  71.  
  72. BEGIN (* MoveXY *)
  73.  
  74. INLINE(
  75.   $B4/$02                    {   MOV     Ah,2                    ;BIOS position cursor function}
  76.   /$B7/$00                   {   MOV     Bh,0                    ;Page 0}
  77.   /$8A/$B6/>Y                {   MOV     Dh,[BP+>Y]              ;Y coordinate}
  78.   /$FE/$CE                   {   DEC     Dh                      ;Drop by 1}
  79.   /$8A/$96/>X                {   MOV     Dl,[BP+>X]              ;X coordinate}
  80.   /$FE/$CA                   {   DEC     Dl                      ;Drop by 1}
  81.   /$CD/$10                   {   INT     $10                     ;BIOS video interrupt}
  82.       );
  83.  
  84. END   (* MoveXY *);
  85.  
  86. (*----------------------------------------------------------------------*)
  87.  
  88. PROCEDURE Move_Chars_To_Right;
  89.  
  90. VAR
  91.    I          : INTEGER;
  92.    L          : INTEGER;
  93.    C          : CHAR;
  94.    CAttr      : BYTE;
  95.    Hold_Chars : ARRAY[1..300] OF BYTE;
  96.  
  97. BEGIN (* Move_Chars_To_Right *)
  98.  
  99.    IF ( NOT Write_Screen_Memory ) THEN
  100.       FOR I := ( Wrap_Screen_Col - 1 ) DOWNTO XPos DO
  101.          BEGIN
  102.             ReadCXY ( C, I, YPos, CAttr );
  103.             WriteCXY( C, SUCC( I ), YPos, CAttr );
  104.          END
  105.    ELSE
  106.       BEGIN
  107.                                    (* Freeze screen for DoubleDos *)
  108.  
  109.          IF ( MultiTasker = DoubleDos ) THEN
  110.             BEGIN
  111.                TurnOffTimeSharing;
  112.                Get_Screen_Address( DesqView_Screen );
  113.             END;
  114.  
  115.          L := Wrap_Screen_Col - XPos;
  116.          I := PRED( ( PRED( YPos ) * Max_Screen_Col + XPos ) SHL 1 );
  117.  
  118.          IF Wait_For_Retrace THEN
  119.             BEGIN
  120.                MoveFromScreen( DesqView_Screen^.Screen_Image[ I ],
  121.                                Hold_Chars[1], L );
  122.                MoveToScreen  ( Hold_Chars[1],
  123.                                DesqView_Screen^.Screen_Image[ I + 2 ],
  124.                                L );
  125.             END
  126.          ELSE
  127.             MOVE( DesqView_Screen^.Screen_Image[ I ],
  128.                   DesqView_Screen^.Screen_Image[ I + 2 ],
  129.                   L SHL 1 );
  130.                                    (* Unfreeze screen in DoubleDos *)
  131.  
  132.          IF ( MultiTasker = DoubleDos ) THEN
  133.             TurnOnTimeSharing
  134.                                    (* Synchronize screen for TopView *)
  135.  
  136.          ELSE IF ( MultiTasker = TopView ) THEN
  137.             Sync_Screen( I , SUCC( L ) );
  138.  
  139.       END;
  140.  
  141. END   (* Move_Chars_To_Right *);
  142.  
  143. (*----------------------------------------------------------------------*)
  144.  
  145. BEGIN (* Display_Character *)
  146.                                    (* Select display depending on *)
  147.                                    (* character.                  *)
  148.    Disp := FALSE;
  149.  
  150.    IF ( ( ORD( Ch ) < 32 ) AND ( NOT Graphics_Mode ) ) THEN
  151.       CASE ORD( Ch ) OF
  152.  
  153.          CR   :    IF Add_LF THEN
  154.                       BEGIN
  155.                          IF Capture_On THEN
  156.                             Capture_Char( LF_Ch );
  157.                          IF Printer_On THEN
  158.                             WRITE( Lst , CR_Ch , LF_Ch );
  159.                          WRITE( CR_Ch, LF_Ch );
  160.                          Last_Column_Hit := FALSE;
  161.                          IF Review_On THEN
  162.                             Update_Review_Pointers;
  163.                       END
  164.                    ELSE
  165.                       BEGIN
  166.                          WRITE( CR_Ch );
  167.                          Last_Column_Hit := FALSE;
  168.                          IF Printer_On THEN
  169.                             WRITE( Lst , CR_Ch );
  170.                       END;
  171.  
  172.          LF   :    IF NOT Add_LF THEN
  173.                       BEGIN
  174.                          IF Capture_On THEN
  175.                             Capture_Char( LF_Ch );
  176.                          WRITE( LF_Ch );
  177.                          IF Printer_On THEN
  178.                             WRITE( Lst , LF_Ch );
  179.                          IF Review_On THEN
  180.                             Update_Review_Pointers;
  181.                       END;
  182.  
  183.          BS   :    BEGIN
  184.                       WRITE( Ch );
  185.                       IF Capture_On THEN
  186.                          Capture_Char( Ch );
  187.                       IF Printer_On THEN
  188.                          WRITE( Lst , Ch );
  189.                       IF Review_On THEN
  190.                          BEGIN
  191.                             J := ORD( Review_Line[0] );
  192.                             IF ( J > 0 ) THEN
  193.                                Review_Line[0] := CHR( J - 1 );
  194.                          END;
  195.                    END;
  196.  
  197.          NUL  :    ;               (* Strip Nulls              *)
  198.  
  199.                                    (* Strip unattached XONs    *)
  200.          XON  :    Disp := NOT Do_Xon_Xoff_Checks;
  201.  
  202.          BELL :    IF Not Silent_Mode THEN
  203.                       WRITE( Ch );
  204.  
  205.          HT   :    BEGIN
  206.  
  207.                       L := 9 - WhereX MOD 8;
  208.  
  209.                       FOR I := 1 TO L DO
  210.                          BEGIN
  211.                             WRITE( BL_Ch );
  212.                             IF Review_On THEN
  213.                                BEGIN
  214.                                   J := SUCC(ORD( Review_Line[0] ));
  215.                                   Review_Line[J] := ' ';
  216.                                   Review_Line[0] := CHR( J );
  217.                                END;
  218.                          END;
  219.  
  220.                       IF ( Capture_On AND Exact_Capture ) THEN
  221.                          Capture_Char( Ch );
  222.  
  223.                       IF Printer_On THEN
  224.                          FOR I := 1 TO L DO
  225.                             WRITE( Lst , BL_Ch );
  226.  
  227.                    END;
  228.  
  229.          VT, FF:   BEGIN
  230.                       IF Capture_On THEN
  231.                          Capture_Char( Ch );
  232.                       IF Printer_On THEN
  233.                          WRITE( Lst , Ch );
  234.                       IF ( NOT ( Terminal_To_Emulate IN Ansi_Set ) ) THEN
  235.                          Clear_Window
  236.                       ELSE
  237.                          BEGIN
  238.                             WRITE( LF_Ch );
  239.                             IF Review_On THEN
  240.                                Update_Review_Pointers;
  241.                          END;
  242.                    END;
  243.  
  244.          ELSE
  245.                    Disp := TRUE;
  246.  
  247.       END (* CASE *)
  248.    ELSE
  249.       Disp := TRUE;
  250.  
  251.    IF Disp AND ( ORD( Ch ) <> DEL ) THEN
  252.       BEGIN
  253.  
  254.          XPos := WhereX + Upper_Left_Column - 1;
  255.          YPos := WhereY + Upper_Left_Row    - 1;
  256.  
  257.          IF ( XPos < Wrap_Screen_Col ) THEN
  258.             BEGIN
  259.                IF Insertion_Mode THEN
  260.                   Move_Chars_To_Right;
  261.                WriteCXY( Ch, XPos, YPos, Global_Text_Attribute );
  262.                MoveXY( SUCC( XPos ) , YPos );
  263.                Last_Column_Hit := FALSE;
  264.             END
  265.          ELSE
  266.             BEGIN
  267.                IF Auto_Wrap_Mode THEN
  268.                   BEGIN
  269.                      IF Last_Column_Hit THEN
  270.                         BEGIN
  271.                            IF ( Capture_On AND ( NOT Exact_Capture ) ) THEN
  272.                               Capture_Char( CHR( LF ) );
  273.                            WRITELN;
  274.                            XPos            := WhereX + Upper_Left_Column - 1;
  275.                            YPos            := WhereY + Upper_Left_Row    - 1;
  276.                         END;
  277.                      Last_Column_Hit := NOT Last_Column_Hit;
  278.                      WriteCXY( Ch, XPos, YPos, Global_Text_Attribute );
  279.                      IF ( NOT Last_Column_Hit ) THEN
  280.                         MoveXY( SUCC( XPos ) , YPos );
  281.                   END
  282.                ELSE
  283.                   BEGIN
  284.                      WriteCXY( Ch, Wrap_Screen_Col, YPos, Global_Text_Attribute );
  285.                      Last_Column_Hit := TRUE;
  286.                   END;
  287.             END;
  288.  
  289.          IF Review_On THEN
  290.             BEGIN
  291.                J := SUCC(ORD( Review_Line[0] ));
  292.                IF ( J < Max_Review_Line_Length ) THEN
  293.                   BEGIN
  294.                      Review_Line[J] := Ch;
  295.                      Review_Line[0] := CHR( J );
  296.                   END;
  297.             END;
  298.  
  299.          IF Capture_On THEN
  300.             Capture_Char( Ch );
  301.  
  302.          IF Printer_On THEN
  303.             WRITE( Lst , Ch );
  304.  
  305.       END;
  306.  
  307. END   (* Display_Character *);
  308.